<planForAudioEvolution>

<mainGoal>
	Realtime audio playing through speakers learns to change to cause a Human
	listening to move the mouse in certain ways. Similarly and simultaneously,
	the Human learns to move the mouse to cause the audio to sound more like music.
	This may later be scaled up to 2 Humans with 2 mouses, and both audios
	learn to cause both Humans to move both mouses in the same way.
	If one Human moves his mouse, the other Human should unconsciously be
	caused to move his mouse the same way, because the sound he hears changes.
</mainGoal>

<surfaceOfTheSystem>
<human>
	Listens to speakers, and moves the mouse to try to make it sound more like music.
	Writes root audio-measure goal. Selects evolved subgoals of that to become more important or replace the root goal.
</human>
<mouse>
	Based on how the Human moves the mouse, change the sound from the speakers to cause the Human to move the mouse a certain way.
	Mouse movement can be viewed as 2-channel audio at slow sampling speed.
</mouse>
<speakers>
	Human hears speakers. Based on Humans interaction with mouse, change the sound.
</speakers>
<audioMeasures>
	<possibleInterface>f(d) --> slow changing d</possibleInterface>
	<rootAudioMeasureGoal>
		Written or chosen by Human at runtime
		May be unnecessary if goals depend only on mouse
	</rootAudioMeasureGoal>
</audioMeasures>
<guiWindowForHumanToChooseThings>Displayed rarely.</guiWindowForHumanToChooseThings>
</surfaceOfTheSystem>

<majorPartsOfTheSystem>
<artificialIntelligenceNetworks>
	<possibleInterface>
		<interfacePerNode>
			Per network, fixed number of "ports", which can be input or output. Each port has:
				floating point value
					More relevant if value is more known. Becomes more relevant if higher "want to know" (output).
				floating point amount that value is known
					High for inputs, low for outputs (becomes high).
				floating point amount we want to know that value
					Low for inputs, high for outputs.
		</interfacePerNode>
		<howManyDatas>
			X audio samples of a few seconds each, and Y audio measures
				X*Y total datasets.
				2 networks, 1 size X and 1 size Y.
					Learn which audio samples are similar, which are redundant,
						and which are probable when others are probable or improbable, etc.
					Learn which audio measures are similar, which are redundant,
						and which are probable when others are probable or improbable, etc.
					Keep samples and measures that are more unique and high-scoring.
		</howManyDatas>
	</possibleInterface>
	<possibleInterface>
		<booleans>
			timeIsAnalog //used if timeExists
			timeExists
			varNodeCount
		</booleans>
		<doubles></doubles>
		<ints>
			nodeCount
		</ints>
	</possibleInterface>
	<possibleInterface>
		Input sequence of setOfNodeThing, and output sequence of setOfNodeThing.
		<setOfNodeThing>
			<forEachNode>
				<doubleWeight>for input, how much we know, for output, how much accuracy we want</doubleWeight>
				<doubleAmount/>
			</forEachNode>
		</setOfNodeThing>
		Complicates networks that do not use time, like bayesian, which should probably input all nodes and output all nodes.
		Are the sequences of setOfNodeThing variable size? For natural language neural networks, they must be variable size.
		Do all nodeThing need weight? Natural language comes from a sequence of words, so weights dont make sense for inputs.
		Should a network have [min and max] [input and output] sequence sizes?
		Should min and max for input and output always be equal, but specific inputs and outputs can differ?
		For a natural language network, 1-15 sequences (each is a word) may be a good range.
		Can networks be run 1 sequence at a time to avoid specifying input and output min and max sequence quantity?
	</possibleInterface>
	<possibleInterface>
		<summary>
			<inputSummary>
				Add 0 or more nodes. Change any numbers in any nodes.
				Run the network's main execute function, which may leave the network in a stable state or not.
				The main function does nothing if the network is in a stable state.
				Adding nodes or changing numbers usually puts the network in an unstable state.
				If the network state is stable or not is deterministic and the measure of that never changes.
			</inputSummary>
			<outputSummary>
			</outputSummary>
		</summary>
		<details>
			To call a network, add 1 or more nodes (same type as in the network), and run the networks normal algorithm.
			The nodes you add should have data that causes them to be sorted to the front of the networks execution list,
			and they can be removed after the network finishes this calculation.
			The output of the network should be 1 or more nodes, but who should create them and what should they connect to?
			To specify 100 node values in a bayesian network, a bayesian node size 100 would have too many weights,
			so multiple bayesian nodes are needed.
		</details>
		<questions>
			<question>Can networks main function add or remove nodes?</question>
			<question>Should there be a secondary function of the network that adds or removes nodes?</question>
			<question>
				Should output start from a constant node (or set of nodes) and go in unknown direction (or branch to many)?
				For example, a natural language neural network, output maybe should start at an input node, and whatever
				words come after that, should be output, or maybe only the word it ends at, and repeat that to get a sentence.
				<possibleAnswer>
					Maybe its best for a network to not know what inputs or outputs are, and not to change its quantity of nodes.
					Those things can be done by something that uses the network. A network should only have 1 function, which does its main calculation.
				</possibleAnswer>
			</question>
			<question>
				Should a network know if it is in a stable state,
				or should you have to run its main function again and see if anything changes to know that?
			</question>
		</questions>
	</possibleInterface>
	<possibleInterface>
		Network does not know what input or output is.
		Network has only 1 function which has no parameters, does 1 time cycle, and returns quantity of nodes left an unstable state.
		<metaNetworkInterface>
			Input a specific type of network, and it may modify that network by adding or removing nodes.
			For example, in a bayesian network where one node is irrelevant to all the other nodes, that irrelevant node may be removed,
			or nodes with less dependence on their parent may be disconnected from that parent.
		</metaNetworkInterface>
		<useDLambdaFor>
			Network has some number of nodes. Each node connects to specific other nodes,
			and has a number of doubles that depends only on its child count.
			<example>
				For example, if child count is C, number of doubles may equal 5 + C*3 + C^4 + 7*2^C,
				and there is some sequence of DLambda calls that reads and writes 5 + 3 + 1 + 7 doubles at a time
				(or something similar, C^4 doesnt line up with 7*2^C, but does line up with C^4*7*2^C, for example).
				To fix the nonalignment, maybe 7*2^C should be repeated C^4 times, while only the C^4 varies.
				Order of the parts of 5 + C*3 + C^4 + 7*2^C does not matter. 5 + 7*2^C + C^4 + C*3 is the same,
				except for order of parameters in the DLambdas.
			</example>			
		</useDLambdaFor>
	</possibleInterface>
	<exampleOfSpecificInterface>
		bayesNet where all nodes have 3 double vars (each 0 to 1): chance, knowChance, and wantChance.
		Defaults are chance=.5, knowChance=0, wantChance=0. To call the bayesNet, set the defaults, then overwrite some of them.			
	</exampleOfSpecificInterface>
	<exampleOfSpecificInterface>
		neural network. input order of nodes, possibly with duplicates. Output order of nodes, possibly with duplicates.
	</exampleOfSpecificInterface>		
</artificialIntelligenceNetworks>
<audioSamples>
	<possibleInterface>f() --> next d</possibleInterface>
	<possibleInterface>array of d</possibleInterface>
	at most 5 seconds each.
</audioSamples>
<audioTransformFunctions>
	<possibleInterface>f(d) --> fast changing d</possibleInterface>
	hard coded and/or evolved
	Lambda, stateless
		many inputs and outputs (to be cycled together) for keeping state outside the lambda.
</audioTransformFunctions>
<audioMeasures>
	<possibleInterface>f(d) --> slow changing d</possibleInterface>
	Root audio measure goal, defined or chosen by Human
	Evolved audio measures
</audioMeasures>
<historyOfData>
	<possibleInterface>Same as multiple channels of audioSamples</possibleInterface>
	History of mouse movements and audio from speakers at same times.
</historyOfData>
<simpleMouseInterpreter>
	If mouse is not moving (for how long?), do not learn from that because Human probably not holding mouse.
</simpleMouseInterpreter>
<resourceAllocator>
	Determines how much memory, cpu, and hard-drive space can be used by each part of the program.
</resourceAllocator>
</majorPartsOfTheSystem>
		
<optionalPartsOfTheSystem>
<internet>
	More Humans
		Connect their subconsicous minds simultaneously through audio and mouse movements, with no direct communication.
</internet>
<microphone>
	Evolve functions of 1 audio input sample to 1 audio output sample, similar to nonmicrophone audio transform functions.
</microphone>
<javaClassGenerator>
	Optimizes code by compiling it to Java classes.
	Possible examples: JDK, Javassist, JPDA
</javaClassGenerator>
<keyboard>
	Some buttons are variables in audio equations
</keyboard>
<screenPixels>
	Use sequences of pixel brightness and color directly as audio data, including different directions on the screen.
		Directions on screen include those similar to mouse movements.
</screenPixels>
<nonAudioLearning>
	Use Humans interactions with mouse and speakers to play chess, natural language, integer factoring, writing code, etc.
</nonAudioLearning>
</optionalPartsOfTheSystem>

</planForAudioEvolution>